import os
import pandas as pd

csv_path = os.path.join("data", "bob_el_corrupto.csv")
empresas = pd.read_csv(csv_path, index_col=0)
print("Dimensiones originales:", empresas.shape) #Verificamos las dimensiones

# Si hay un desajuste...
if empresas.shape[0] != empresas.shape[1]:
    # Si hay más columnas que filas
    if empresas.shape[1] > empresas.shape[0]:
        empresas = empresas.iloc[:, :-1]  # Eliminamos la última columna
    # Si hay más filas que columnas
    else:
        empresas = empresas.iloc[:-1, :]  # Eliminamos la última fila

# Nos aseguramos que sean los mismos nombres
empresas.index = empresas.columns
empresas.head()

Dimensiones originales: (444, 444)

empresas.columns

Index(['ZRINCON_EIRL', 'MIROVAL_SAC', 'METACONTROL_SAC', 'CORONEL_EJECUTORES',
       'WAR_SAC', 'GIMAHU', 'HUAYCHAOLA_SAC', 'JAGIXA',
       'CONSTRUCTORA_DOLPHIN_SAC', 'JD&HN',
       ...
       'INVERSIONES_CAVIANDINA_SAC', 'DAZER_CONSTRUCTION_SAC', 'GRALAZ_SAC',
       'ECOTRAM_EIRL', 'CORPORACION_INGENIERIA_Y_DESARROLLO_SAC',
       'W&W_CONSTRUCTORES_SAC', 'GEOTEGG_SAC', 'MAKI_ASOCIADOS_SAC',
       'COINVEFER_EIRL', 'G&P_EL_ROBLE_SAC'],
      dtype='object', length=444)

import networkx as nx
EmpresaNet = nx.from_pandas_adjacency(empresas)

nx.draw_random(EmpresaNet,
                node_color='yellow',
                edge_color='lightblue',
                with_labels=True,
                font_size=8)

import matplotlib.pyplot as plt

plt.figure(figsize=(15, 15)) 
pos = nx.spring_layout(EmpresaNet, k=0.5)  

nx.draw(
    EmpresaNet,
    pos,
    node_color='yellow',
    edge_color='lightblue',
    with_labels=True,
    font_size=8,
    node_size=100,  # Ajusta el tamaño del nodo
    alpha=0.8,  # Ajustar la opacidad
    linewidths=0.5,  # Ajustar el ancho de los bordes
)

plt.title("Visualización del Grafo de Empresas", fontsize=16)
plt.axis('off')  
plt.show()

EmpresaNet.remove_edges_from(nx.selfloop_edges(EmpresaNet))

plt.figure(figsize=(15, 15)) 
pos = nx.spring_layout(EmpresaNet, k=0.5)  

nx.draw(
    EmpresaNet,
    pos,
    node_color='yellow',
    edge_color='lightblue',
    with_labels=True,
    font_size=8,
    node_size=100,  # Ajusta el tamaño del nodo
    alpha=0.8,  # Ajustar la opacidad
    linewidths=0.5,  # Ajustar el ancho de los bordes
)

plt.title("Visualización del Grafo de Empresas", fontsize=16)
plt.axis('off')  
plt.show()

type(EmpresaNet)

networkx.classes.graph.Graph

len(EmpresaNet.nodes),len(EmpresaNet.edges) #edges es aristas

(444, 4582)

nx.is_connected(EmpresaNet)

False

len(list(nx.connected_components(EmpresaNet)))

21

[len(c) for c in sorted(nx.connected_components(EmpresaNet), key=len, reverse=True)]

[390, 5, 5, 5, 4, 4, 4, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1]

list(nx.isolates(EmpresaNet))

['ALTAS_CUMBRES_SAC', 'MICLEBY_SAC', 'JL_BARRIENTOS_SAC']

largest_cc_nodes = max(nx.connected_components(EmpresaNet), key=len)
EmpresaNet_largest=EmpresaNet.subgraph(largest_cc_nodes)

nx.diameter(EmpresaNet_largest)

6

# geodesics - indican las distancias más cortas entre los nodos
geodesics = dict(nx.all_pairs_shortest_path_length(EmpresaNet))

# as matrix
MatrixGeo = [[geodesics.get(n,{}).get(m)  for m in EmpresaNet.nodes] for n in EmpresaNet.nodes]

# as DF (pandas)
MatrixGeo_DF=pd.DataFrame(MatrixGeo,index=EmpresaNet.nodes, columns=EmpresaNet.nodes)

# we get
MatrixGeo_DF

import numpy as np

pd.DataFrame(np.unique(MatrixGeo_DF.values, return_counts=True),index=['valor','freq']).T.set_index('valor')

import warnings
warnings.filterwarnings('ignore')

MatrixReach_DF=(MatrixGeo_DF>0).replace({True:1,False:0})
MatrixReach_DF

# connectedness
nNodes=len(EmpresaNet_largest.nodes)
MatrixReach_DF.sum().sum()/(nNodes*(nNodes-1))

1.0008305319359303

# geodesics
geodesics_Lcc = dict(nx.all_pairs_shortest_path_length(EmpresaNet_largest))

# as matrix
MatrixGeo_Lcc = [[geodesics_Lcc.get(n,{}).get(m)  for m in EmpresaNet_largest.nodes] for n in EmpresaNet_largest.nodes]

# as DF (pandas)
MatrixGeo_DF_Lcc=pd.DataFrame(MatrixGeo_Lcc,index=EmpresaNet_largest.nodes, columns=EmpresaNet_largest.nodes)

# we get
MatrixGeo_DF_Lcc

# reachability
MatrixReach_DF_Lcc=(MatrixGeo_DF_Lcc>0).replace({True:1,False:0})
MatrixReach_DF_Lcc

# connectedness
nNodes=len(EmpresaNet_largest.nodes)
MatrixReach_DF_Lcc.sum().sum()/(nNodes*(nNodes-1))

1.0

nx.density(EmpresaNet_largest)

0.05958737064135522

enterpriseMeasures=pd.concat([pd.DataFrame.from_dict(nx.degree_centrality(EmpresaNet_largest),
                                  orient='index',
                                  columns=['Degree']),
           pd.DataFrame.from_dict(nx.closeness_centrality(EmpresaNet_largest),
                                  orient='index',
                                  columns=['Closeness']),
           pd.DataFrame.from_dict(nx.betweenness_centrality(EmpresaNet_largest),
                                  orient='index',
                                  columns=['Betweenness'])],axis=1)
## data
enterpriseMeasures

fig, ax = plt.subplots(figsize=(10,10))

ax.scatter(enterpriseMeasures.Closeness, enterpriseMeasures.Degree,s=1000*enterpriseMeasures.Betweenness,
           c=100*enterpriseMeasures.Betweenness,
           cmap=plt.get_cmap('YlOrRd'), alpha=0.6)

valsForAnnotate=zip(enterpriseMeasures.index,enterpriseMeasures.Closeness,enterpriseMeasures.Degree)
for name,coordX,coordY in valsForAnnotate:
    ax.annotate(name, (coordX,coordY),alpha=0.5)

plt.title("Centrality  (size and  color for Betweenness)", y=-0.1)
plt.xlabel("Closeness")
plt.ylabel("Degree")
plt.show()

fig, ax = plt.subplots(figsize=(12, 12))

scatter = ax.scatter(enterpriseMeasures.Closeness, enterpriseMeasures.Degree, 
                     s=1000 * enterpriseMeasures.Betweenness, 
                     c=enterpriseMeasures.Betweenness, cmap='YlOrRd', alpha=0.6, edgecolor='black', linewidth=0.5)

valsForAnnotate = zip(enterpriseMeasures.index, enterpriseMeasures.Closeness, enterpriseMeasures.Degree)

# Mostrar solo nombres que no se superpongan
for name, coordX, coordY in valsForAnnotate:
    if enterpriseMeasures.Betweenness.loc[name] > enterpriseMeasures.Betweenness.quantile(0.98):  # Top 2%
        ax.annotate(name, (coordX, coordY), fontsize=8, alpha=0.7)


plt.title("Centrality (size and color for Betweenness)", fontsize=16, y=1.02)
plt.xlabel("Closeness", fontsize=14)
plt.ylabel("Degree", fontsize=14)

cbar = plt.colorbar(scatter)
cbar.set_label('Betweenness Centrality', fontsize=12)
cbar.ax.tick_params(labelsize=10)

plt.grid(True, linestyle='--', alpha=0.5)
plt.xlim(left=0)  # Limitar el eje x si es necesario
plt.ylim(bottom=0)  # Limitar el eje y si es necesario

plt.show()

componentes = list(nx.connected_components(EmpresaNet))

pos = nx.spring_layout(EmpresaNet)  # Posiciones de los nodos
plt.figure(figsize=(12, 12))

# Dibuja cada componente con su color
for i, comp in enumerate(componentes):
    color = plt.cm.viridis(i / len(componentes))  # Diferentes colores para cada componente
    nx.draw_networkx_nodes(EmpresaNet, pos, nodelist=comp, node_color=color, alpha=0.5)

nx.draw_networkx_edges(EmpresaNet, pos, alpha=0.5)

# Ajustar la leyenda
handles = [plt.Line2D([0], [0], marker='o', color='w', label=f'Componente {i+1}',
                       markerfacecolor=plt.cm.viridis(i / len(componentes)), markersize=10)
           for i in range(len(componentes))]

plt.legend(handles=handles, loc='upper right', bbox_to_anchor=(1.1, 1), title="Componentes")

plt.title("Componentes Conectados")
plt.axis('off')  # Oculta los ejes
plt.show()

warnings.filterwarnings('ignore')
from pyvis.network import Network
import networkx as nx
import matplotlib.pyplot as plt

# Crea un objeto de red de Pyvis
net = Network(height="750px", width="100%", notebook=True)

# Encontrar componentes conectados
componentes = list(nx.connected_components(EmpresaNet))

# Dibuja cada componente con su color
for i, comp in enumerate(componentes):
    color = plt.cm.viridis(i / len(componentes))  # Diferentes colores para cada componente
    for node in comp:
        # Agregar nodos a la red interactiva
        net.add_node(str(node), label=str(node), color=f'rgba({int(color[0]*255)}, {int(color[1]*255)}, {int(color[2]*255)}, {color[3]})')

# Agregar bordes a la red
for u, v in EmpresaNet.edges():
    net.add_edge(str(u), str(v))

# Ajustar opciones de repulsión para que los nodos no se amontonen
net.repulsion(node_distance=300, spring_length=150)

# Mostrar la red
net.show("red_interactiva_componentes.html")

Warning: When  cdn_resources is 'local' jupyter notebook has issues displaying graphics on chrome/safari. Use cdn_resources='in_line' or cdn_resources='remote' if you have issues viewing graphics in a notebook.
red_interactiva_componentes.html

	freq
valor
0.0	444.0
1.0	9164.0
2.0	56896.0
3.0	65758.0
4.0	18308.0
5.0	1654.0
6.0	56.0
NaN	44856.0

	Degree	Closeness	Betweenness
ZRINCON_EIRL	0.197943	0.476132	0.032889
MIROVAL_SAC	0.113111	0.420996	0.005088
METACONTROL_SAC	0.174807	0.496173	0.019790
CORONEL_EJECUTORES	0.087404	0.424672	0.004195
WAR_SAC	0.043702	0.386296	0.000000
...	...	...	...
W&W_CONSTRUCTORES_SAC	0.071979	0.401031	0.000000
GEOTEGG_SAC	0.071979	0.401031	0.000000
MAKI_ASOCIADOS_SAC	0.071979	0.401031	0.000000
COINVEFER_EIRL	0.071979	0.401031	0.000000
G&P_EL_ROBLE_SAC	0.071979	0.401031	0.000000

Networks¶

Sistema de contratación del Estado y las empresas que ganaron licitaciones de obras¶

Cantidad de veces que las empresas se encontraron trabajando para un distrito en el año 2023¶

Exploramos¶

Distancias¶

Density¶

Centralidad¶

¿Qué hemos calculado?¶

Degree¶

Closeness¶

Betweenness¶

Comunidades¶